package com.shlh.saas.controller;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.shlh.saas.common.Result;
import com.shlh.saas.common.UserContext;
import com.shlh.saas.entity.UserBalance;
import com.shlh.saas.entity.twitter.TwitterUser;
import com.shlh.saas.model.dto.TwitterQueryDTO;
import com.shlh.saas.service.UserBalanceService;
import com.shlh.saas.service.WorkbenchStatsService;
import com.shlh.saas.service.twitter.TwitterService;
import com.shlh.saas.util.ExcelUtils;
import com.shlh.saas.service.ExportRecordService;
import com.shlh.saas.util.FileUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Twitter用户控制器
 */
@RestController
@RequestMapping("/twitter")
@Slf4j
public class TwitterController {
    
    @Autowired
    private TwitterService twitterService;
    
    @Autowired
    private WorkbenchStatsService workbenchStatsService;
    
    @Autowired
    private UserBalanceService userBalanceService;
    
    @Autowired
    private ExportRecordService exportRecordService;
    
    /**
     * 获取Twitter用户列表
     */
    @GetMapping("/users")
    public Result getTwitterUser(@RequestParam(required = false) String name,
                                  @RequestParam(defaultValue = "1") Integer page,
                                  @RequestParam(defaultValue = "12") Integer limit) {
        try {
            // 获取当前用户ID
            Long userId = UserContext.getUserId();
            
            // 第一页不扣除额度，免费查看
            if (page == 1) {
                TwitterQueryDTO queryDTO = new TwitterQueryDTO();
                queryDTO.setName(name);
                queryDTO.setPageNum(page);
                queryDTO.setPageSize(limit);
                
                Page<TwitterUser> pageResult = twitterService.getTwitterUsersPage(queryDTO);
                
                // 增加搜索次数统计
                workbenchStatsService.incrementTwitterSearchCount(userId);
                
                Map<String, Object> data = new HashMap<>();
                data.put("total", pageResult.getTotal());
                data.put("data", pageResult.getRecords());
                data.put("size", pageResult.getSize());
                data.put("current", pageResult.getCurrent());
                
                return Result.success(data);
            } else {
                // 检查用户余额
                UserBalance userBalance = userBalanceService.getByUserId(userId);
                if (userBalance == null || userBalance.getViewRecordsRemaining() < limit) {
                    return Result.error("您的查看记录余额不足，请充值后再查看");
                }
                
                TwitterQueryDTO queryDTO = new TwitterQueryDTO();
                queryDTO.setName(name);
                queryDTO.setPageNum(page);
                queryDTO.setPageSize(limit);
                
                Page<TwitterUser> pageResult = twitterService.getTwitterUsersPage(queryDTO);
                
                // 扣除用户查看记录余额
                userBalanceService.deductViewRecords(userId, pageResult.getRecords().size());
                
                // 增加搜索次数统计
                workbenchStatsService.incrementTwitterSearchCount(userId);
                
                Map<String, Object> data = new HashMap<>();
                data.put("total", pageResult.getTotal());
                data.put("data", pageResult.getRecords());
                data.put("size", pageResult.getSize());
                data.put("current", pageResult.getCurrent());
                
                return Result.success(data);
            }
        } catch (Exception e) {
            log.error("获取Twitter用户列表出错: {}", e.getMessage());
            return Result.error("获取Twitter用户列表失败: " + e.getMessage());
        }
    }
    
    /**
     * 根据筛选条件获取Twitter用户列表
     */
    @PostMapping("/filter")
    public Result filterTwitterUser(@RequestBody TwitterQueryDTO queryDTO) {
        try {
            // 获取当前用户ID
            Long userId = UserContext.getUserId();
            
            // 获取页码和每页大小
            int page = queryDTO.getPageNum() != null ? queryDTO.getPageNum() : 1;
            int size = queryDTO.getPageSize() != null ? queryDTO.getPageSize() : 12;
            
            // 第一页不扣除额度，免费查看
            if (page == 1) {
                // 执行查询
                Page<TwitterUser> pageResult = twitterService.getTwitterUsersPage(queryDTO);
                
                // 增加搜索次数统计
                workbenchStatsService.incrementTwitterSearchCount(userId);
                
                Map<String, Object> data = new HashMap<>();
                data.put("total", pageResult.getTotal());
                data.put("data", pageResult.getRecords());
                data.put("size", pageResult.getSize());
                data.put("current", pageResult.getCurrent());
                
                return Result.success(data);
            } else {
                // 检查用户余额
                UserBalance userBalance = userBalanceService.getByUserId(userId);
                if (userBalance == null || userBalance.getViewRecordsRemaining() < size) {
                    return Result.error("您的查看记录余额不足，请充值后再查看");
                }
                
                // 执行查询
                Page<TwitterUser> pageResult = twitterService.getTwitterUsersPage(queryDTO);
                
                // 扣除用户查看记录余额
                userBalanceService.deductViewRecords(userId, pageResult.getRecords().size());
                
                // 增加搜索次数统计
                workbenchStatsService.incrementTwitterSearchCount(userId);
                
                Map<String, Object> data = new HashMap<>();
                data.put("total", pageResult.getTotal());
                data.put("data", pageResult.getRecords());
                data.put("size", pageResult.getSize());
                data.put("current", pageResult.getCurrent());
                
                return Result.success(data);
            }
        } catch (Exception e) {
            log.error("Twitter筛选查询出错: {}", e.getMessage());
            return Result.error("获取Twitter用户数据失败: " + e.getMessage());
        }
    }
    
    /**
     * 获取Twitter用户详情
     */
    @GetMapping("/users/{id}")
    public Result getTwitterUserDetail(@PathVariable Integer id) {
        TwitterUser twitterUser = twitterService.getTwitterUserById(id);
        if (twitterUser == null) {
            return Result.error("用户不存在");
        }
        return Result.success(twitterUser);
    }
    
    /**
     * 获取符合条件的记录总数
     */
    @PostMapping("/count")
    public Result countTwitterData(@RequestBody TwitterQueryDTO queryDTO) {
        log.info("计算符合条件的Twitter数据数量，参数: {}", queryDTO);
        
        long count = twitterService.countTwitterUsers(queryDTO);
        
        // 限制最大返回数量为100万
        if (count > 50000) {
            count = 50000;
        }
        
        Map<String, Object> result = new HashMap<>();
        result.put("count", count);
        return Result.success(result);
    }
    
    /**
     * 导出Twitter用户数据
     */
    @PostMapping("/export")
    public void exportTwitterUser(
            HttpServletResponse response,
            @RequestBody TwitterQueryDTO queryDTO,
            @RequestParam(required = true) Integer exportCount) {
        log.info("导出Twitter用户数据，参数: {}, 导出数量: {}", queryDTO, exportCount);
        try {
            // 获取当前用户ID
            Long userId = UserContext.getUserId();
            
            // 检查用户余额
            UserBalance userBalance = userBalanceService.getByUserId(userId);
            if (userBalance == null || userBalance.getExportQuotaRemaining() < exportCount) {
                response.setContentType("application/json;charset=UTF-8");
                response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
                response.getWriter().write("{\"message\":\"您的导出次数余额不足，请充值后再导出\"}");
                return;
            }
            
            // 限制最大导出数量为5万
            if (exportCount > 50000) {
                exportCount = 50000;
            }
            
            // 设置导出限制
            queryDTO.setLimit(exportCount);
            
            // 获取数据
            List<TwitterUser> dataList = twitterService.exportTwitterUsers(queryDTO);
            log.info("查询到 {} 条数据准备导出", dataList.size());
            
            if (dataList.isEmpty()) {
                response.setContentType("application/json;charset=UTF-8");
                response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
                response.getWriter().write("{\"message\":\"没有找到符合条件的数据\"}");
                return;
            }
            
            // 扣除用户导出次数余额
            userBalanceService.deductExportQuota(userId, dataList.size());
            
            // 增加导出次数统计
            workbenchStatsService.incrementTwitterExportCount(userId, dataList.size());
            
            // 设置导出文件名和表头
            String fileName = "Twitter用户数据_" + System.currentTimeMillis();
            String[] columnNames = {
                "用户名", "昵称", "粉丝数", "注册时间", "邮箱"
            };
            String[] fields = {
                "screenName", "name", "followersCount", "createdAt", "email"
            };
            
            // 获取当前时间戳作为文件名一部分
            String filePath = "/export/" + fileName + ".xlsx";
            
            // 计算文件大小（以KB为单位）
            String fileSize = FileUtils.estimateExcelSize(dataList.size()) + "KB";
            
            // 保存导出记录
            exportRecordService.addExportRecord(
                userId,
                fileName + ".xlsx",
                "twitter", // 数据来源
                fileSize,
                dataList.size(),
                filePath
            );
            
            // 设置必要的响应头
            response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
            response.setCharacterEncoding("utf-8");
            response.setHeader("Connection", "Keep-Alive");
            response.setHeader("Proxy-Connection", "Keep-Alive");
            
            // 根据数据量选择不同的导出方法
            if (dataList.size() > 10000) {
                log.info("数据量超过10000条，使用优化的Excel导出方法");
                // 导出Excel (使用优化方法)
                ExcelUtils.exportExcelOptimized(response, dataList, fileName, columnNames, fields);
            } else {
                // 导出Excel (使用标准方法)
                ExcelUtils.exportExcel(response, dataList, "Twitter用户数据", columnNames, fields);
            }
            log.info("成功导出Twitter数据");
            
        } catch (Exception e) {
            log.error("导出Twitter数据失败", e);
            try {
                // 检查response是否已经提交
                if (!response.isCommitted()) {
                    response.reset();
                    response.setContentType("application/json;charset=UTF-8");
                    response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                    response.getWriter().write("{\"message\":\"导出数据失败: " + e.getMessage() + "\"}");
                } else {
                    log.warn("响应已经提交，无法发送错误信息");
                }
            } catch (IOException ex) {
                log.error("写入错误响应失败", ex);
            }
        }
    }
    
    /**
     * 导入Twitter用户数据
     */
    @PostMapping("/import")
    public Result importTwitterUser(@RequestParam("file") MultipartFile file) {
        if (file.isEmpty()) {
            return Result.error("请选择要上传的Excel文件");
        }
        
        try {
            // 解析Excel文件并导入数据
            List<TwitterUser> importResult = twitterService.importTwitterUsers(file);
            
            Map<String, Object> data = new HashMap<>();
            data.put("count", importResult.size());
            
            return Result.success(data, "成功导入" + importResult.size() + "条Twitter用户数据");
        } catch (Exception e) {
            log.error("导入Twitter用户数据失败", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }
    
    /**
     * 分页查询Twitter用户列表
     */
    @PostMapping("/list")
    public Result getTwitterUserList(@RequestBody TwitterQueryDTO queryDTO) {
        try {
            // 获取当前用户ID
            Long userId = UserContext.getUserId();
            
            // 获取页码和每页大小
            int page = queryDTO.getPageNum() != null ? queryDTO.getPageNum() : 1;
            int size = queryDTO.getPageSize() != null ? queryDTO.getPageSize() : 12;
            
            // 第一页不扣除额度，免费查看
            if (page == 1) {
                Page<TwitterUser> pageResult = twitterService.getTwitterUserPage(queryDTO);
                
                // 增加搜索次数统计
                workbenchStatsService.incrementTwitterSearchCount(userId);
                
                return Result.success(pageResult);
            } else {
                // 检查用户余额
                UserBalance userBalance = userBalanceService.getByUserId(userId);
                if (userBalance == null || userBalance.getViewRecordsRemaining() < size) {
                    return Result.error("您的查看记录余额不足，请充值后再查看");
                }
                
                Page<TwitterUser> pageResult = twitterService.getTwitterUserPage(queryDTO);
                
                // 扣除用户查看记录余额
                userBalanceService.deductViewRecords(userId, pageResult.getRecords().size());
                
                // 增加搜索次数统计
                workbenchStatsService.incrementTwitterSearchCount(userId);
                
                return Result.success(pageResult);
            }
        } catch (Exception e) {
            log.error("获取Twitter用户列表失败", e);
            return Result.error("获取Twitter用户列表失败");
        }
    }
    
    /**
     * 根据ID获取Twitter用户
     */
    @GetMapping("/{id}")
    public Result getTwitterUserById(@PathVariable Integer id) {
        try {
            TwitterUser user = twitterService.getTwitterUserById(id);
            return Result.success(user);
        } catch (Exception e) {
            log.error("获取Twitter用户详情失败", e);
            return Result.error("获取Twitter用户详情失败");
        }
    }
    
    /**
     * 搜索Twitter用户
     */
//    @GetMapping("/search")
//    public Result searchTwitterUsers(@RequestParam String keyword,
//                                    @RequestParam(defaultValue = "0") int page,
//                                    @RequestParam(defaultValue = "10") int size) {
//        try {
//            // 获取当前用户ID
//            Long userId = UserContext.getUserId();
//
//            // 第一页不扣除额度，免费查看
//            if (page == 0) {
//                List<TwitterUser> users = twitterService.searchTwitterUsers(keyword, page, size);
//                long total = twitterService.countTwitterUsersByKeyword(keyword);
//
//                // 增加搜索次数统计
//                workbenchStatsService.incrementTwitterSearchCount(userId);
//
//                Map<String, Object> data = new HashMap<>();
//                data.put("total", total);
//                data.put("list", users);
//                data.put("size", size);
//                data.put("current", page);
//
//                return Result.success(data);
//            } else {
//                // 检查用户余额
//                UserBalance userBalance = userBalanceService.getByUserId(userId);
//                if (userBalance == null || userBalance.getViewRecordsRemaining() < size) {
//                    return Result.error("您的查看记录余额不足，请充值后再查看");
//                }
//
//                List<TwitterUser> users = twitterService.searchTwitterUsers(keyword, page, size);
//
//                // 扣除用户查看记录余额
//                userBalanceService.deductViewRecords(userId, users.size());
//
//                // 增加搜索次数统计
//                workbenchStatsService.incrementTwitterSearchCount(userId);
//
//                long total = twitterService.countTwitterUsersByKeyword(keyword);
//
//                Map<String, Object> data = new HashMap<>();
//                data.put("total", total);
//                data.put("list", users);
//                data.put("size", size);
//                data.put("current", page);
//
//                return Result.success(data);
//            }
//        } catch (Exception e) {
//            log.error("搜索Twitter用户失败", e);
//            return Result.error("搜索Twitter用户失败");
//        }
//    }
    
    /**
     * 获取所有Twitter用户
     */
    @GetMapping("/all")
    public Result getAllTwitterUsers() {
        try {
            List<TwitterUser> users = twitterService.getAllTwitterUsers();
            return Result.success(users);
        } catch (Exception e) {
            log.error("获取所有Twitter用户失败", e);
            return Result.error("获取所有Twitter用户失败");
        }
    }
    
    /**
     * 获取Twitter用户完整联系信息
     * 需要消耗查看次数额度
     */
    @GetMapping("/contact/full")
    public Result getFullContactInfo(
        @RequestParam String sourceId,
        @RequestParam String sourceTable,
        @RequestParam String field) {
        
        try {
            // 获取当前用户ID
            Long userId = UserContext.getUserId();
            
            // 检查用户余额
            UserBalance userBalance = userBalanceService.getByUserId(userId);
            if (userBalance == null || userBalance.getViewRecordsRemaining() < 1) {
                return Result.error("您的查看记录余额不足，请充值后再查看");
            }
            
            // 获取完整联系信息
            Map<String, String> contactInfo = twitterService.getFullContactInfo(sourceId, sourceTable, field);
            
            if (contactInfo.isEmpty() || contactInfo.get(field) == null) {
                return Result.error("未找到有效的联系信息");
            }
            
            // 扣除用户查看记录余额
            userBalanceService.deductViewRecords(userId, 1);
            
            // 记录查看次数统计
            workbenchStatsService.incrementTwitterSearchCount(userId);
            
            return Result.success(contactInfo);
        } catch (Exception e) {
            log.error("获取Twitter用户完整联系信息失败", e);
            return Result.error("获取联系信息失败: " + e.getMessage());
        }
    }
} 